
#include "IClassByte.h"
#include "member_BClass.h"

using namespace BWE;

ClassByte::ClassByte() : BClass("byte", true)
{
	
	insertMethod("byte()", &ClassByte::create);
	insertMethod("byte(byte)", &ClassByte::create_byte);
	insertMethod("byte(char)", &ClassByte::create_char);
	insertMethod("byte(short)", &ClassByte::create_short);
	insertMethod("byte(int)", &ClassByte::create_int);
	insertMethod("byte(long)", &ClassByte::create_long);
	insertMethod("byte(real)", &ClassByte::create_real);
	insertMethod("byte(float)", &ClassByte::create_float);
	insertMethod("byte(double)", &ClassByte::create_double);
	insertMethod("~char()", &ClassByte::release);

	insertMethod("byte =(bool)", &ClassByte::assign_bool);
	insertMethod("byte =(byte)", &ClassByte::assign_byte);
	insertMethod("byte =(char)", &ClassByte::assign_char);
	insertMethod("byte =(short)", &ClassByte::assign_short);
	insertMethod("byte =(long)", &ClassByte::assign_long);
	insertMethod("byte =(real)", &ClassByte::assign_real);
	insertMethod("byte =(float)", &ClassByte::assign_float);
	insertMethod("byte =(double)", &ClassByte::assign_double);

	insertMethod("byte +()", &ClassByte::positive);
	insertMethod("byte -()", &ClassByte::negative);
	insertMethod("byte ++()", &ClassByte::plus_plus);
	insertMethod("byte --()", &ClassByte::minus_minus);

	insertMethod("byte +(byte)", &ClassByte::plus_byte);
	insertMethod("byte +(char)", &ClassByte::plus_char);
	insertMethod("short +(short)", &ClassByte::plus_short);
	insertMethod("int +(int)", &ClassByte::plus_int);
	insertMethod("long +(long)", &ClassByte::plus_long);
	insertMethod("long +(real)", &ClassByte::plus_real);
	insertMethod("float +(float)", &ClassByte::plus_float);
	insertMethod("double +(double)", &ClassByte::plus_double);

	insertMethod("+=(byte)", &ClassByte::plus_assign_byte);
	insertMethod("+=(char)", &ClassByte::plus_assign_char);
	insertMethod("+=(short)", &ClassByte::plus_assign_short);
	insertMethod("+=(int)", &ClassByte::plus_assign_int);
	insertMethod("+=(long)", &ClassByte::plus_assign_long);
	insertMethod("+=(real)", &ClassByte::plus_assign_real);
	insertMethod("+=(float)", &ClassByte::plus_assign_float);
	insertMethod("+=(double)", &ClassByte::plus_assign_double);

	insertMethod("int -(byte)", &ClassByte::minus_byte);
	insertMethod("int -(char)", &ClassByte::minus_char);
	insertMethod("int -(short)", &ClassByte::minus_short);
	insertMethod("int -(int)", &ClassByte::minus_int);
	insertMethod("long -(long)", &ClassByte::minus_long);
	insertMethod("long -(real)", &ClassByte::minus_real);
	insertMethod("float -(float)", &ClassByte::minus_float);
	insertMethod("double -(double)", &ClassByte::minus_double);

	insertMethod("-=(byte)", &ClassByte::minus_assign_byte);
	insertMethod("-=(char)", &ClassByte::minus_assign_char);
	insertMethod("-=(short)", &ClassByte::minus_assign_short);
	insertMethod("-=(int)", &ClassByte::minus_assign_int);
	insertMethod("-=(long)", &ClassByte::minus_assign_long);
	insertMethod("-=(real)", &ClassByte::minus_assign_real);
	insertMethod("-=(float)", &ClassByte::minus_assign_float);
	insertMethod("-=(double)", &ClassByte::minus_assign_double);

	insertMethod("int %(byte)",		&ClassByte::mod_byte);
	insertMethod("int %(char)",		&ClassByte::mod_char);
	insertMethod("int %(short)",	&ClassByte::mod_short);
	insertMethod("int %(int)",		&ClassByte::mod_int);
	insertMethod("long %(long)",	&ClassByte::mod_long);
	insertMethod("long %(real)",	&ClassByte::mod_real);
	insertMethod("float %(float)",	&ClassByte::mod_float);
	insertMethod("double %(double)",&ClassByte::mod_double);

	insertMethod("%=(byte)",	&ClassByte::mod_assign_byte);
	insertMethod("%=(char)",	&ClassByte::mod_assign_char);
	insertMethod("%=(short)",	&ClassByte::mod_assign_short);
	insertMethod("%=(int)",		&ClassByte::mod_assign_int);
	insertMethod("%=(long)",	&ClassByte::mod_assign_long);
	insertMethod("%=(real)",	&ClassByte::mod_assign_real);
	insertMethod("%=(float)",	&ClassByte::mod_assign_float);
	insertMethod("%=(double)",	&ClassByte::mod_assign_double);

	insertMethod("bool ==(bool)", &ClassByte::equal_bool);
	insertMethod("bool ==(byte)", &ClassByte::equal_byte);
	insertMethod("bool ==(char)", &ClassByte::equal_char);
	insertMethod("bool ==(short)", &ClassByte::equal_short);
	insertMethod("bool ==(int)", &ClassByte::equal_int);
	insertMethod("bool ==(long)", &ClassByte::equal_long);
	insertMethod("bool ==(real)", &ClassByte::equal_real);
	insertMethod("bool ==(float)", &ClassByte::equal_float);
	insertMethod("bool ==(double)", &ClassByte::equal_double);

	insertMethod("bool !=(bool)", &ClassByte::unequal_bool);
	insertMethod("bool !=(byte)", &ClassByte::unequal_byte);
	insertMethod("bool !=(char)", &ClassByte::unequal_char);
	insertMethod("bool !=(short)", &ClassByte::unequal_short);
	insertMethod("bool !=(int)", &ClassByte::unequal_int);
	insertMethod("bool !=(long)", &ClassByte::unequal_long);
	insertMethod("bool !=(real)", &ClassByte::unequal_real);
	insertMethod("bool !=(float)", &ClassByte::unequal_float);
	insertMethod("bool !=(double)", &ClassByte::unequal_double);

	insertMethod("bool >(byte)", &ClassByte::greater_byte);
	insertMethod("bool >(char)", &ClassByte::greater_char);
	insertMethod("bool >(short)", &ClassByte::greater_short);
	insertMethod("bool >(int)", &ClassByte::greater_int);
	insertMethod("bool >(long)", &ClassByte::greater_long);
	insertMethod("bool >(real)", &ClassByte::greater_real);
	insertMethod("bool >(float)", &ClassByte::greater_float);
	insertMethod("bool >(double)", &ClassByte::greater_double);

	insertMethod("bool <(byte)", &ClassByte::less_byte);
	insertMethod("bool <(char)", &ClassByte::less_char);
	insertMethod("bool <(short)", &ClassByte::less_short);
	insertMethod("bool <(int)", &ClassByte::less_int);
	insertMethod("bool <(long)", &ClassByte::less_long);
	insertMethod("bool <(real)", &ClassByte::less_real);
	insertMethod("bool <(float)", &ClassByte::less_float);
	insertMethod("bool <(double)", &ClassByte::less_double);

	insertMethod("bool >=(byte)", &ClassByte::greater_equal_byte);
	insertMethod("bool >=(char)", &ClassByte::greater_equal_char);
	insertMethod("bool >=(short)", &ClassByte::greater_equal_short);
	insertMethod("bool >=(int)", &ClassByte::greater_equal_int);
	insertMethod("bool >=(long)", &ClassByte::greater_equal_long);
	insertMethod("bool >=(real)", &ClassByte::greater_equal_real);
	insertMethod("bool >=(float)", &ClassByte::greater_equal_float);
	insertMethod("bool >=(double)", &ClassByte::greater_equal_double);

	insertMethod("bool <=(byte)", &ClassByte::less_equal_byte);
	insertMethod("bool <=(char)", &ClassByte::less_equal_char);
	insertMethod("bool <=(short)", &ClassByte::less_equal_short);
	insertMethod("bool <=(int)", &ClassByte::less_equal_int);
	insertMethod("bool <=(long)", &ClassByte::less_equal_long);
	insertMethod("bool <=(real)", &ClassByte::less_equal_real);
	insertMethod("bool <=(float)", &ClassByte::less_equal_float);
	insertMethod("bool <=(double)", &ClassByte::less_equal_double);
}

void ClassByte::create(int argc, BValue* argv)
{
	argv[0].refer() = 0;
}
void ClassByte::create_byte(int argc, BValue* argv)
{
	BByte byte = argv[1];
	argv[0].refer() = byte;
}
void ClassByte::create_char(int argc, BValue* argv)
{
	char c = argv[1];
	argv[0].refer() = (BByte)c;
}
void ClassByte::create_short(int argc, BValue* argv)
{
	short s = argv[1];
	argv[0].refer() = (BByte)s;
}
void ClassByte::create_int(int argc, BValue* argv)
{
	int i = argv[1];
	argv[0].refer() = (BByte)i;
}
void ClassByte::create_long(int argc, BValue* argv)
{
	long long l = argv[1];
	argv[0].refer() = (BByte)l;
}
void ClassByte::create_real(int argc, BValue* argv)
{
	BReal r = argv[1];
	argv[0].refer() = (BByte)r;
}
void ClassByte::create_float(int argc, BValue* argv)
{
	float f = argv[1];
	argv[0].refer() = (BByte)f;
}
void ClassByte::create_double(int argc, BValue* argv)
{
	double d = argv[1];
	argv[0].refer() = (BByte)d;
}
void ClassByte::release(int argc, BValue* argv)
{
	argv[0].refer().clear();
}

void ClassByte::assign_bool(int argc, BValue* argv)
{
	bool b = argv[1];
	argv[0] = BByte(b ? 1 : 0);
}
void ClassByte::assign_byte(int argc, BValue* argv)
{
	BByte byte = argv[1];
	argv[0] = byte;
}
void ClassByte::assign_char(int argc, BValue* argv)
{
	char c = argv[1];
	argv[0] = (BByte)c;
}
void ClassByte::assign_short(int argc, BValue* argv)
{
	short s = argv[1];
	argv[0] = (BByte)s;
}
void ClassByte::assign_int(int argc, BValue* argv)
{
	int i = argv[1];
	argv[0] = (BByte)i;
}
void ClassByte::assign_long(int argc, BValue* argv)
{
	long long f = argv[1];
	argv[0] = (BByte)f;
}
void ClassByte::assign_real(int argc, BValue* argv)
{
	BReal r = argv[1];
	argv[0] = (BByte)r;
}
void ClassByte::assign_float(int argc, BValue* argv)
{
	int f = argv[1];
	argv[0] = (BByte)f;
}
void ClassByte::assign_double(int argc, BValue* argv)
{
	double d = argv[1];
	argv[0] = (BByte)d;
}

void ClassByte::positive(int argc, BValue* argv)
{

}
void ClassByte::negative(int argc, BValue* argv)
{
	BByte& v = argv[0];
	argv[0] = -v;
}
void ClassByte::plus_plus(int argc, BValue* argv)
{
	BByte& v = argv[0];
	argv[0] = v++;
}
void ClassByte::minus_minus(int argc, BValue* argv)
{
	BByte& v = argv[0];
	argv[0] = v--;
}

void ClassByte::plus_byte(int argc, BValue* argv)
{

}
void ClassByte::plus_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v + c);
}
void ClassByte::plus_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v + s);
}
void ClassByte::plus_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v + i);
}
void ClassByte::plus_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v + l);
}
void ClassByte::plus_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v + r);
}
void ClassByte::plus_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v + f);
}
void ClassByte::plus_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v + d);
}

void ClassByte::plus_assign_byte(int argc, BValue* argv)
{
	BByte& v = argv[0];
	BByte byte = argv[1];
	v = v + byte;
}
void ClassByte::plus_assign_char(int argc, BValue* argv)
{
	BByte& v = argv[0];
	char c = argv[1];
	v = v + c;
}
void ClassByte::plus_assign_short(int argc, BValue* argv)
{
	BByte& v = argv[0];
	short s = argv[1];
	v = (char)(v + s);
}
void ClassByte::plus_assign_int(int argc, BValue* argv)
{
	BByte& v = argv[0];
	int i = argv[1];
	v = (char)(v + i);
}
void ClassByte::plus_assign_long(int argc, BValue* argv)
{
	BByte& v = argv[0];
	long long l = argv[1];
	v = (char)(v + l);
}
void ClassByte::plus_assign_real(int argc, BValue* argv)
{
	BByte& v = argv[0];
	BReal r = argv[1];
	v = (char)(v + r);
}
void ClassByte::plus_assign_float(int argc, BValue* argv)
{
	BByte& v = argv[0];
	float f = argv[1];
	v = (char)(v + f);
}
void ClassByte::plus_assign_double(int argc, BValue* argv)
{
	BByte& v = argv[0];
	double d = argv[1];
	v = (char)(v + d);
}

void ClassByte::minus_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v - b);
}
void ClassByte::minus_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v - c);
}
void ClassByte::minus_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v - s);
}
void ClassByte::minus_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v - i);
}
void ClassByte::minus_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v - l);
}
void ClassByte::minus_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v - r);
}
void ClassByte::minus_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v - f);
}
void ClassByte::minus_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v - d);
}

void ClassByte::minus_assign_byte(int argc, BValue* argv)
{
	BByte& v = argv[0];
	BByte b = argv[1];
	v = v - b;
}
void ClassByte::minus_assign_char(int argc, BValue* argv)
{
	BByte& v = argv[0];
	char c = argv[1];
	v = (BByte)(v - c);
}
void ClassByte::minus_assign_short(int argc, BValue* argv)
{
	BByte& v = argv[0];
	short s = argv[1];
	v = (BByte)(v - s);
}
void ClassByte::minus_assign_int(int argc, BValue* argv)
{
	BByte& v = argv[0];
	int i = argv[1];
	v = (BByte)(v - i);
}
void ClassByte::minus_assign_long(int argc, BValue* argv)
{
	BByte& v = argv[0];
	long long l = argv[1];
	v = (BByte)(v - l);
}
void ClassByte::minus_assign_real(int argc, BValue* argv)
{
	BByte& v = argv[0];
	BReal r = argv[1];
	v = (BByte)(v - r);
}
void ClassByte::minus_assign_float(int argc, BValue* argv)
{
	BByte& v = argv[0];
	float f = argv[1];
	v = (BByte)(v - f);
}
void ClassByte::minus_assign_double(int argc, BValue* argv)
{
	BByte& v = argv[0];
	double d = argv[1];
	v = (BByte)(v - d);
}

void ClassByte::mod_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v % b);
}
void ClassByte::mod_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v % c);
}
void ClassByte::mod_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v % s);
}
void ClassByte::mod_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v % i);
}
void ClassByte::mod_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v % l);
}
void ClassByte::mod_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v % (int)r);
}
void ClassByte::mod_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v % (int)f);
}
void ClassByte::mod_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v % (int)d);
}

void ClassByte::mod_assign_byte(int argc, BValue* argv)
{
	BByte& v = argv[0];
	BByte b = argv[1];
	v = v % b;
}
void ClassByte::mod_assign_char(int argc, BValue* argv)
{
	BByte& v = argv[0];
	char c = argv[1];
	v = BByte(v % c);
}
void ClassByte::mod_assign_short(int argc, BValue* argv)
{
	BByte& v = argv[0];
	short s = argv[1];
	v = (BByte)(v % s);
}
void ClassByte::mod_assign_int(int argc, BValue* argv)
{
	BByte& v = argv[0];
	int i = argv[1];
	v = (BByte)(v % i);
}
void ClassByte::mod_assign_long(int argc, BValue* argv)
{
	BByte& v = argv[0];
	long long l = argv[1];
	v = (BByte)(v % (int)l);
}
void ClassByte::mod_assign_real(int argc, BValue* argv)
{
	BByte& v = argv[0];
	BReal r = argv[1];
	v = (BByte)(v % (int)r);
}
void ClassByte::mod_assign_float(int argc, BValue* argv)
{
	BByte& v = argv[0];
	float f = argv[1];
	v = (BByte)(v % (int)f);
}
void ClassByte::mod_assign_double(int argc, BValue* argv)
{
	BByte& v = argv[0];
	double d = argv[1];
	v = (BByte)(v % (int)d);
}

void ClassByte::equal_bool(int argc, BValue* argv)
{
	BByte v = argv[0];
	bool b = argv[1];
	argv[0] = ((bool)v == b);
}
void ClassByte::equal_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v == b);
}
void ClassByte::equal_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v == c);
}
void ClassByte::equal_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v == s);
}
void ClassByte::equal_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v == i);
}
void ClassByte::equal_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v == l);
}
void ClassByte::equal_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v == r);
}
void ClassByte::equal_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v == f);
}
void ClassByte::equal_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v == d);
}

void ClassByte::unequal_bool(int argc, BValue* argv)
{
	BByte v = argv[0];
	bool b = argv[1];
	argv[0] = ((bool)v != b);
}
void ClassByte::unequal_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v != b);
}
void ClassByte::unequal_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v != c);
}
void ClassByte::unequal_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v != s);
}
void ClassByte::unequal_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v != i);
}
void ClassByte::unequal_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v != l);
}
void ClassByte::unequal_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v != r);
}
void ClassByte::unequal_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v != f);
}
void ClassByte::unequal_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v != d);
}

void ClassByte::greater_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v > b);
}
void ClassByte::greater_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v > c);
}
void ClassByte::greater_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v > s);
}
void ClassByte::greater_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v > i);
}
void ClassByte::greater_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v > l);
}
void ClassByte::greater_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v > r);
}
void ClassByte::greater_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v > f);
}
void ClassByte::greater_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v > d);
}

void ClassByte::less_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v < b);
}
void ClassByte::less_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v < c);
}
void ClassByte::less_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v < s);
}
void ClassByte::less_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v < i);
}
void ClassByte::less_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v < l);
}
void ClassByte::less_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v < r);
}
void ClassByte::less_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v < f);
}
void ClassByte::less_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v < d);
}

void ClassByte::greater_equal_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v >= b);
}
void ClassByte::greater_equal_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v >= c);
}
void ClassByte::greater_equal_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v >= s);
}
void ClassByte::greater_equal_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v >= i);
}
void ClassByte::greater_equal_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v >= l);
}
void ClassByte::greater_equal_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v >= r);
}
void ClassByte::greater_equal_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v >= f);
}
void ClassByte::greater_equal_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v >= d);
}

void ClassByte::less_equal_byte(int argc, BValue* argv)
{
	BByte v = argv[0];
	BByte b = argv[1];
	argv[0] = (v <= b);
}
void ClassByte::less_equal_char(int argc, BValue* argv)
{
	BByte v = argv[0];
	char c = argv[1];
	argv[0] = (v <= c);
}
void ClassByte::less_equal_short(int argc, BValue* argv)
{
	BByte v = argv[0];
	short s = argv[1];
	argv[0] = (v <= s);
}
void ClassByte::less_equal_int(int argc, BValue* argv)
{
	BByte v = argv[0];
	int i = argv[1];
	argv[0] = (v <= i);
}
void ClassByte::less_equal_long(int argc, BValue* argv)
{
	BByte v = argv[0];
	long long l = argv[1];
	argv[0] = (v <= l);
}
void ClassByte::less_equal_real(int argc, BValue* argv)
{
	BByte v = argv[0];
	BReal r = argv[1];
	argv[0] = (v <= r);
}
void ClassByte::less_equal_float(int argc, BValue* argv)
{
	BByte v = argv[0];
	float f = argv[1];
	argv[0] = (v <= f);
}
void ClassByte::less_equal_double(int argc, BValue* argv)
{
	BByte v = argv[0];
	double d = argv[1];
	argv[0] = (v <= d);
}
